home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpuzzles.3 / xpuzzles / xpuzzles-5.3.1 / xtriangles / TrianglesU.c < prev    next >
C/C++ Source or Header  |  1996-02-05  |  7KB  |  273 lines
  1. /*
  2. # X-BASED TRIANGLES
  3. #
  4. #  TrianglesU.c
  5. #
  6. ###
  7. #
  8. #  Copyright (c) 1994 - 96    David Albert Bagley, bagleyd@hertz.njit.edu
  9. #
  10. #                   All Rights Reserved
  11. #
  12. #  Permission to use, copy, modify, and distribute this software and
  13. #  its documentation for any purpose and without fee is hereby granted,
  14. #  provided that the above copyright notice appear in all copies and
  15. #  that both that copyright notice and this permission notice appear in
  16. #  supporting documentation, and that the name of the author not be
  17. #  used in advertising or publicity pertaining to distribution of the
  18. #  software without specific, written prior permission.
  19. #
  20. #  This program is distributed in the hope that it will be "playable",
  21. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23. #
  24. */
  25.  
  26. /* Undo algorithm */
  27.  
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <X11/IntrinsicP.h>
  31. #include <X11/Intrinsic.h>
  32. #include <X11/StringDefs.h>
  33. #include <X11/CoreP.h>
  34. #include "TrianglesP.h"
  35.  
  36. typedef struct _MoveRecord
  37. {
  38.   /* int direction; */
  39.   unsigned char packed; /* This makes assumptions on the data. */
  40. } MoveRecord;
  41.  
  42. typedef struct _MoveStack
  43. {
  44.   MoveRecord move;
  45.   struct _MoveStack *previous, *next;
  46. } MoveStack;
  47.  
  48. static MoveStack *currMove, *lastMove, *firstMove;
  49. static int count;
  50. static int startSpace[MAXORIENT];
  51. static int startRow[MAXORIENT][ROWTYPES];
  52. int *startPosition = NULL;
  53.  
  54. static void InitStack();
  55. static void PushStack();
  56. static void PopStack();
  57. static int EmptyStack();
  58. static void FlushStack();
  59.  
  60. static void InitStack()
  61. {
  62.   if (!(lastMove = (MoveStack *) malloc(sizeof(MoveStack))))
  63.     XtError("Not enough memory, exiting.");
  64.   if (!(firstMove = (MoveStack *) malloc(sizeof(MoveStack))))
  65.     XtError("Not enough memory, exiting.");
  66.   firstMove->previous = lastMove->next = NULL;
  67.   firstMove->next = lastMove;
  68.   lastMove->previous = firstMove;
  69.   count = 0;
  70. }
  71.  
  72. static void PushStack(move)
  73.   MoveRecord move;
  74. {
  75.   if (!(currMove = (MoveStack *) malloc(sizeof(MoveStack))))
  76.     XtError("Not enough memory, exiting.");
  77.   lastMove->previous->next = currMove;
  78.   currMove->previous = lastMove->previous;
  79.   currMove->next = lastMove;
  80.   lastMove->previous = currMove;
  81.   currMove->move = move;
  82.   count++;
  83. }
  84.  
  85. static void PopStack(move)
  86.   MoveRecord *move;
  87. {
  88.   *move = lastMove->previous->move;
  89.   currMove = lastMove->previous;
  90.   lastMove->previous->previous->next = lastMove;
  91.   lastMove->previous = lastMove->previous->previous;
  92.   (void) free((void *) currMove);
  93.   count--;
  94. }
  95.  
  96. static int EmptyStack()
  97. {
  98.   return (lastMove->previous == firstMove);
  99. }
  100.  
  101. static void FlushStack()
  102. {
  103.   while (lastMove->previous != firstMove) {
  104.     currMove = lastMove->previous;
  105.     lastMove->previous->previous->next = lastMove;
  106.     lastMove->previous = lastMove->previous->previous;
  107.     (void) free((void *) currMove);
  108.   }
  109.   count = 0;
  110. }
  111.  
  112. /**********************************/
  113.  
  114. void InitMoves()
  115. {
  116.   InitStack();
  117. }
  118.  
  119. static void WriteMove(move, direction)
  120.   MoveRecord *move;
  121.   int direction;
  122. {
  123.   /* move->direction = direction; */
  124.   move->packed = direction & 0xF;
  125. }
  126.  
  127. static void ReadMove(direction, move)
  128.   int *direction;
  129.   MoveRecord move;
  130. {
  131.   /* *direction = move.direction; */
  132.   *direction = move.packed & 0xF;
  133. }
  134.  
  135. void PutMove(direction)
  136.   int direction;
  137. {
  138.   MoveRecord move;
  139.  
  140.   WriteMove(&move, direction); 
  141.   PushStack(move);
  142. }
  143.  
  144. void GetMove(direction)
  145.   int *direction;
  146. {
  147.   MoveRecord move;
  148.  
  149.   PopStack(&move);
  150.   ReadMove(direction, move);
  151. }
  152.  
  153. int MadeMoves()
  154. {
  155.   return !EmptyStack();
  156. }
  157.  
  158. void FlushMoves(w)
  159.   TrianglesWidget w;
  160. {
  161.   int i;
  162.  
  163.   FlushStack();
  164.   startSpace[UP] = w->triangles.spacePosition[UP];
  165.   startSpace[DOWN] = w->triangles.spacePosition[DOWN];
  166.   startRow[UP][TRBL] = w->triangles.spaceRow[UP][TRBL];
  167.   startRow[UP][TLBR] = w->triangles.spaceRow[UP][TLBR];
  168.   startRow[UP][ROW] = w->triangles.spaceRow[UP][ROW];
  169.   startRow[DOWN][TRBL] = w->triangles.spaceRow[DOWN][TRBL];
  170.   startRow[DOWN][TLBR] = w->triangles.spaceRow[DOWN][TLBR];
  171.   startRow[DOWN][ROW] = w->triangles.spaceRow[DOWN][ROW];
  172.   for (i = 0; i < w->triangles.sizeSize; i++)
  173.     startPosition[i] = w->triangles.tileOfPosition[i];
  174. }
  175.  
  176. int NumMoves()
  177. {
  178.   return count;
  179. }
  180.  
  181. void ScanMoves(fp, w, moves)
  182.   FILE *fp;
  183.   TrianglesWidget w;
  184.   int moves;
  185. {
  186.   int direction, l;
  187.   char c;
  188.  
  189.   for (l = 0; l < moves; l++) {
  190.     while ((c = getc(fp)) != EOF && c != SYMBOL);
  191.     (void) fscanf(fp, "%d", &direction);
  192.     if (!MoveTrianglesDir(w, direction))
  193.       (void) fprintf(fp, "%d move in direction %d, can not be made.",
  194.         l, direction);
  195.   }
  196. }
  197.  
  198. void PrintMoves(fp)
  199.   FILE *fp;
  200. {
  201.   int direction, counter = 0;
  202.  
  203.   currMove = firstMove->next;
  204.   (void) fprintf(fp, "moves\tdir\n"); 
  205.   while (currMove != lastMove) {
  206.     ReadMove(&direction, currMove->move);;
  207.     (void) fprintf(fp, "%d%c\t%d\n", ++counter, SYMBOL, direction); 
  208.     currMove = currMove->next;
  209.   }
  210. }
  211.  
  212. void ScanStartPosition(fp, w)       
  213.   FILE *fp;
  214.   TrianglesWidget w;
  215. {
  216.   int i, num;
  217.   char c;
  218.  
  219.   while ((c = getc(fp)) != EOF && c != SYMBOL);
  220.   for (i = 0; i < w->triangles.sizeSize; i++) {
  221.     (void) fscanf(fp, "%d ", &num);
  222.     startPosition[i] = num;
  223.     if (!num)
  224.       startSpace[UP] = i;
  225.     else if (num == -1)
  226.       startSpace[DOWN] = i;
  227.   }
  228.   for (i = DOWN; i <= UP; i++) {
  229.     startRow[i][ROW] = Row(startSpace[i]);
  230.     startRow[i][TRBL] = TrBl(startSpace[i], startRow[i][ROW]) / 2;
  231.     startRow[i][TLBR] = TlBr(startSpace[i], startRow[i][ROW]) / 2;
  232.   }
  233. }
  234.  
  235. void PrintStartPosition(fp, w)       
  236.   FILE *fp;
  237.   TrianglesWidget w;
  238. {
  239.   int r = 0, p, space, temp;
  240.  
  241.   (void) fprintf(fp, "\nstartingPosition%c\n", SYMBOL);
  242.   for (p = 0; p < w->triangles.sizeSize; p++) {
  243.     if (p == r * r)
  244.       for (space = 0; space < w->triangles.size - r - 1; space++)
  245.         (void) fprintf(fp, "    ");
  246.     (void) fprintf(fp, "%3d ", startPosition[p]);
  247.     temp = (r + 1) * (r + 1) - 1;
  248.     if (p == temp) {
  249.       (void) fprintf(fp, "\n");
  250.       r++;
  251.     }
  252.   }
  253.   (void) fprintf(fp, "\n");
  254. }
  255.  
  256. void SetStartPosition(w)       
  257.   TrianglesWidget w;
  258. {
  259.   int i;
  260.  
  261.   w->triangles.spacePosition[UP] = startSpace[UP];
  262.   w->triangles.spacePosition[DOWN] = startSpace[DOWN];
  263.   w->triangles.spaceRow[UP][TRBL] = startRow[UP][TRBL];
  264.   w->triangles.spaceRow[UP][TLBR] = startRow[UP][TLBR];
  265.   w->triangles.spaceRow[UP][ROW] = startRow[UP][ROW];
  266.   w->triangles.spaceRow[DOWN][TRBL] = startRow[DOWN][TRBL];
  267.   w->triangles.spaceRow[DOWN][TLBR] = startRow[DOWN][TLBR];
  268.   w->triangles.spaceRow[DOWN][ROW] = startRow[DOWN][ROW];
  269.   for (i = 0; i < w->triangles.sizeSize; i++)
  270.     w->triangles.tileOfPosition[i] = startPosition[i];
  271.   DrawAllTiles(w, w->triangles.tileGC, w->triangles.borderGC);
  272. }
  273.